{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "        del X_train, y_train\n",
    "        del X_test, y_test\n",
    "        print('Clear previously loaded data.')\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.356196\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *For a random W, we expect the score of each catagory is all equal to zero. Hence the possiblity of certain catagory is 1/10. Thus loss will be close to $-\\log(0.1)$.* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.277239 analytic: -1.277239, relative error: 2.377528e-08\n",
      "numerical: -1.672242 analytic: -1.672242, relative error: 2.209837e-09\n",
      "numerical: 0.136094 analytic: 0.136094, relative error: 7.917713e-08\n",
      "numerical: 0.654891 analytic: 0.654891, relative error: 2.581023e-08\n",
      "numerical: 0.218213 analytic: 0.218212, relative error: 1.385352e-07\n",
      "numerical: 0.696266 analytic: 0.696266, relative error: 1.769684e-08\n",
      "numerical: -1.772524 analytic: -1.772524, relative error: 3.636921e-08\n",
      "numerical: 0.488168 analytic: 0.488168, relative error: 4.654752e-08\n",
      "numerical: -0.285030 analytic: -0.285031, relative error: 3.061059e-07\n",
      "numerical: 1.312965 analytic: 1.312965, relative error: 2.133652e-08\n",
      "numerical: -0.616452 analytic: -0.616452, relative error: 5.743178e-08\n",
      "numerical: 0.366476 analytic: 0.366476, relative error: 3.185328e-08\n",
      "numerical: -0.202089 analytic: -0.202089, relative error: 1.377568e-07\n",
      "numerical: -0.829194 analytic: -0.829194, relative error: 8.745341e-09\n",
      "numerical: 0.354180 analytic: 0.354180, relative error: 2.291609e-08\n",
      "numerical: 0.922009 analytic: 0.922009, relative error: 2.581897e-08\n",
      "numerical: 1.926206 analytic: 1.926206, relative error: 5.350523e-09\n",
      "numerical: 1.707622 analytic: 1.707622, relative error: 1.860545e-08\n",
      "numerical: 1.211878 analytic: 1.211878, relative error: 2.731452e-08\n",
      "numerical: 1.608396 analytic: 1.608396, relative error: 6.357035e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vectorized loss: 2.356170e+00 computed in 0.061764s\n"
     ]
    }
   ],
   "source": [
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.356170e+00 computed in 0.113681s\n",
      "vectorized loss: 2.356170e+00 computed in 0.043812s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 776.545807\n",
      "iteration 100 / 1500: loss 284.810849\n",
      "iteration 200 / 1500: loss 105.500160\n",
      "iteration 300 / 1500: loss 39.899907\n",
      "iteration 400 / 1500: loss 15.946536\n",
      "iteration 500 / 1500: loss 7.205325\n",
      "iteration 600 / 1500: loss 3.940441\n",
      "iteration 700 / 1500: loss 2.736819\n",
      "iteration 800 / 1500: loss 2.320252\n",
      "iteration 900 / 1500: loss 2.219247\n",
      "iteration 1000 / 1500: loss 2.150672\n",
      "iteration 1100 / 1500: loss 2.048482\n",
      "iteration 1200 / 1500: loss 2.039173\n",
      "iteration 1300 / 1500: loss 2.083988\n",
      "iteration 1400 / 1500: loss 2.083348\n",
      "iteration 0 / 1500: loss 2.155035\n",
      "iteration 100 / 1500: loss 2.147476\n",
      "iteration 200 / 1500: loss 2.089552\n",
      "iteration 300 / 1500: loss 2.124168\n",
      "iteration 400 / 1500: loss 2.107336\n",
      "iteration 500 / 1500: loss 2.112178\n",
      "iteration 600 / 1500: loss 2.132963\n",
      "iteration 700 / 1500: loss 2.129834\n",
      "iteration 800 / 1500: loss 2.197523\n",
      "iteration 900 / 1500: loss 2.142224\n",
      "iteration 1000 / 1500: loss 2.159792\n",
      "iteration 1100 / 1500: loss 2.156776\n",
      "iteration 1200 / 1500: loss 2.141613\n",
      "iteration 1300 / 1500: loss 2.132002\n",
      "iteration 1400 / 1500: loss 2.135730\n",
      "iteration 0 / 1500: loss 2.200237\n",
      "iteration 100 / 1500: loss 2.154687\n",
      "iteration 200 / 1500: loss 2.114953\n",
      "iteration 300 / 1500: loss 2.057639\n",
      "iteration 400 / 1500: loss 2.067675\n",
      "iteration 500 / 1500: loss 2.085313\n",
      "iteration 600 / 1500: loss 2.018446\n",
      "iteration 700 / 1500: loss 2.092455\n",
      "iteration 800 / 1500: loss 2.156182\n",
      "iteration 900 / 1500: loss 2.082691\n",
      "iteration 1000 / 1500: loss 2.064452\n",
      "iteration 1100 / 1500: loss 2.103367\n",
      "iteration 1200 / 1500: loss 2.092203\n",
      "iteration 1300 / 1500: loss 2.111323\n",
      "iteration 1400 / 1500: loss 2.077709\n",
      "iteration 0 / 1500: loss 2.194502\n",
      "iteration 100 / 1500: loss 2.159997\n",
      "iteration 200 / 1500: loss 2.139795\n",
      "iteration 300 / 1500: loss 2.168387\n",
      "iteration 400 / 1500: loss 2.161499\n",
      "iteration 500 / 1500: loss 2.157477\n",
      "iteration 600 / 1500: loss 2.169858\n",
      "iteration 700 / 1500: loss 2.105321\n",
      "iteration 800 / 1500: loss 2.153427\n",
      "iteration 900 / 1500: loss 2.198582\n",
      "iteration 1000 / 1500: loss 2.186269\n",
      "iteration 1100 / 1500: loss 2.126046\n",
      "iteration 1200 / 1500: loss 2.156363\n",
      "iteration 1300 / 1500: loss 2.150941\n",
      "iteration 1400 / 1500: loss 2.185759\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.325102 val accuracy: 0.341000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.314714 val accuracy: 0.320000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.327878 val accuracy: 0.346000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.314612 val accuracy: 0.321000\n",
      "best validation accuracy achieved during cross-validation: 0.346000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "sfmx = Softmax()\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        _ = sfmx.train(X_train, y_train, learning_rate=lr, reg=reg,\n",
    "                       num_iters=1500, verbose=True)\n",
    "        y_train_pred = sfmx.predict(X_train)\n",
    "        y_val_pred = sfmx.predict(X_val)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        results[(lr, reg)] = (train_accuracy, val_accuracy)\n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_softmax = sfmx\n",
    "        \n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.325000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ This statement is **True**. \n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$ For SVM, if it could classify the new datapoint correctly, the increase of loss will be zero. For Softmas classifier, unless it predict the new datapoint correctly and gives score=1 for this new datapoint, the loss will change, since $-\\log(P)$ changes with $P$ all the time.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The advantage of linear model is that: the \"true image\" of each catagory can be visualized like above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
